home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK2.toast / Development Kits (Disc 2) / OpenDoc / OpenDoc Development / Debugging Support / OpenDoc™ Source Code / Messaging / OSL / CntxtOSL.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-28  |  12.3 KB  |  392 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        CntxtOSL.c
  3.  
  4.     Contains:    New functions specific to this Context version of the OSL
  5.  
  6.     Owned by:    Nick Pilch
  7.  
  8.     Copyright:    © 1993 - 1995 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.         <11>     8/29/95    jpa        DescPtr --> AEDesc* for Univ Hdrs 2.1.
  13.                                     [1279173]
  14.         <10>     6/27/95    NP        1262792: new version of OSLObjectInit
  15.          <9>     6/23/95    NP        1195474: Make Resolve reentrant.
  16.          <8>      5/3/95    NP        1211084: Remove 5$
  17.          <7>     4/25/95    NP        1186795, 1237220, 1240571: Fixed whose
  18.                                     clauses by allowing swapping in count proc.
  19.          <6>     2/22/95    eeh        1222904: fix use of SetCurrentContext
  20.          <5>      2/8/95    NP        1218550: Don't allocate OSLContexts
  21.                                     dynamically.
  22.          <4>     1/22/95    NP        Create dummy pascal routines for other
  23.                                     exportable routines in the OSL.
  24.          <3>    11/15/94    NP        1196322-made functions non-pascal. Added
  25.                                     glue code.
  26.          <2>     8/19/94    NP        1181622: Ownership fix.
  27.          <9>      2/7/94    NP        Tiger Team doings.
  28.          <8>    12/20/93    NP        Changed CountProc to be able to switch
  29.                                     contexts.
  30.          <7>    10/22/93    NP        Added OSLCallObjectAccessor.
  31.          <6>    10/18/93    NP        Support for the rest of the callback
  32.                                     functions.
  33.          <5>    10/11/93    NP        Implemented new count and compare callback
  34.                                     dispatch routines.
  35.          <4>     9/24/93    JA        Minor syntactic tweaks for THINK C++.
  36.          <3>     8/18/93    NP        Mods for new context scheme.
  37.          <2>     8/16/93    NP        Implementing.
  38.          <1>     8/16/93    NP        first checked in
  39.  
  40.     To Do:
  41. */
  42.  
  43. #ifndef _CNTXTOSL_
  44. #include "CntxtOSL.h"
  45. #endif
  46.  
  47. #ifndef __AEOBJECTS__
  48. #include <AEObjects.h>
  49. #endif
  50.  
  51. #ifndef _OSLPRIV_
  52. #include "OSLPriv.h"
  53. #endif
  54.  
  55. #ifndef _OSLTOKEN_
  56. #include "OSLToken.h"
  57. #endif
  58.  
  59. #pragma segment CntxtOSL
  60.  
  61. OSErr CREATEOBJSPECIFIER(DescType desiredClass, AEDesc *theContainer, DescType keyForm, AEDesc *keyData, Boolean disposeInputs, AEDesc *objSpecifier);
  62. OSErr CREATERANGEDESCRIPTOR(AEDesc *rangeStart, AEDesc *rangeStop, Boolean disposeInputs, AEDesc *theDescriptor);
  63. OSErr CREATELOGICALDESCRIPTOR(AEDescList *theLogicalTerms, DescType theLogicOperator, Boolean disposeInputs, AEDesc *theDescriptor);
  64. OSErr CREATEOFFSETDESCRIPTOR(long theOffset, AEDesc *theDescriptor);
  65. OSErr CREATECOMPDESCRIPTOR(DescType comparisonOperator, AEDesc *operand1, AEDesc *operand2, Boolean disposeInputs, AEDesc *theDescriptor);
  66.  
  67. #pragma lib_export on
  68.  
  69. //------------------------------------------------------------------------------
  70. // OSLObjectInit
  71. //------------------------------------------------------------------------------
  72.  
  73. OSErr OSLObjectInit( OSLContext* context ) 
  74. {
  75.     return iAEObjectInit(context);
  76. }
  77.  
  78. //------------------------------------------------------------------------------
  79. // OSLResolve
  80. //------------------------------------------------------------------------------
  81.  
  82. OSErr OSLResolve(const AEDesc* objectSpecifier, OSLToken* theToken,
  83.                         OSLContext* startingContext)
  84. {
  85.     return iAEResolve(*objectSpecifier, theToken, startingContext);
  86. }
  87.  
  88. //------------------------------------------------------------------------------
  89. // OSLDisposeToken
  90. //------------------------------------------------------------------------------
  91.  
  92. OSErr OSLDisposeToken(OSLToken* theToken)
  93. {
  94.     return iAEDisposeToken(theToken);
  95. }
  96.  
  97. //------------------------------------------------------------------------------
  98. // OSLCallObjectAccessor
  99. //------------------------------------------------------------------------------
  100.  
  101. OSErr OSLCallObjectAccessor(DescType        desiredClass,
  102.                                     const AEDesc    *containerToken,
  103.                                     DescType        containerClass,
  104.                                     DescType        keyForm,
  105.                                     const AEDesc    *keyData,
  106.                                     AEDesc            *token )
  107. {
  108.     return iCallAccessor(desiredClass, *containerToken, containerClass,
  109.                             keyForm, *keyData, token);
  110. }
  111.  
  112. #pragma lib_export off
  113.  
  114. //------------------------------------------------------------------------------
  115. // GetAppDoesFlags
  116. //------------------------------------------------------------------------------
  117.  
  118. OSErr GetAppDoesFlags(OSLContext* context, short* appDoesFlags)
  119. {
  120.     CallbackCallerProc    dispatchProc;
  121.  
  122.     dispatchProc = (*context->getCallerProc)(kCallbackFlagsGetter);
  123.     *appDoesFlags = (*(CallbackFlagsGetter)dispatchProc)(context->refCon);
  124.     return noErr;
  125. }
  126.  
  127. //------------------------------------------------------------------------------
  128. // NewCallCountProc
  129. //------------------------------------------------------------------------------
  130.  
  131. OSErr NewCallCountProc(DescType        desiredType,
  132.                         DescType    containerClass,
  133.                         OSLToken    container,
  134.                         long*        result)
  135. {
  136.     CallbackCallerProc    dispatchProc;
  137.     OSLContext            context;
  138.     OSErr                error;
  139. //    OSLContext            afterContext;
  140.  
  141.     error = GetCurrentContext(&context);
  142.     if (error)
  143.         return error;
  144.     dispatchProc = (*context.getCallerProc)(kCountProc);
  145.     error = (*(CountProcCaller)dispatchProc)(desiredType, containerClass,
  146.                                                 &container, result,
  147.                                                 context.refCon);
  148.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  149.     {
  150.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  151.         if (aGlobalRef)
  152.         {
  153.             OSLCountUPP aProcPtr = (*aGlobalRef)->countProcPtr ;
  154.             if (aProcPtr)
  155.                 error = CallOSLCountProc(aProcPtr, desiredType, containerClass,
  156.                                             container, result);
  157.         }
  158.     }
  159.     return error;
  160. #if 0
  161.     // CONTEXT CHANGED?
  162.     if (container.descriptorType == kSwitchDescType && (error == noErr))
  163.     {
  164.         // DISPOSE OLD CONTAINER TOKEN????
  165.         error = OSLGetTokenContext(&container, &afterContext);
  166.         if (error)
  167.             return error;
  168.         error = SetCurrentContext(&afterContext);
  169.         if (error)
  170.             return error;
  171.         // DISPOSE TOKEN???? PROBABLY.
  172.         MakeNullToken(&container);
  173.         containerClass = typeNull;
  174.         error = (*(CountProcCaller)dispatchProc)(desiredType, containerClass,
  175.                                                     &container, result,
  176.                                                     context.refCon);
  177.     }
  178. #endif /* 0 */
  179. }
  180.  
  181. //------------------------------------------------------------------------------
  182. // NewCallCompareProc
  183. //------------------------------------------------------------------------------
  184.  
  185. OSErr NewCallCompareProc(DescType            oper,
  186.                             OSLToken        obj1,
  187.                             OSLToken        obj2,
  188.                             Boolean*        result)
  189. {
  190.     CallbackCallerProc    dispatchProc;
  191.     OSLContext            context;
  192.     OSErr                error;
  193.  
  194.     error = GetCurrentContext(&context);
  195.     if (error)
  196.         return error;
  197.     dispatchProc = (*context.getCallerProc)(kCompareProc);
  198.     error =  (*(CompareProcCaller)dispatchProc)(oper, &obj1, &obj2, result,
  199.                                                 context.refCon);
  200.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  201.     {
  202.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  203.         if (aGlobalRef)
  204.         {
  205.             OSLCompareUPP aProcPtr = (*aGlobalRef)->compareProcPtr ;
  206.             if (aProcPtr)
  207.                 error = CallOSLCompareProc(aProcPtr, oper, obj1, obj2, result);
  208.         }
  209.     }
  210.     return error;
  211. }
  212.  
  213. //------------------------------------------------------------------------------
  214. // NewCallAdjustMarks
  215. //------------------------------------------------------------------------------
  216.  
  217. OSErr NewCallAdjustMarks(long newStart, long newStop, OSLToken markToken)
  218. {
  219.     CallbackCallerProc    dispatchProc;
  220.     OSLContext            context;
  221.     OSErr                error;
  222.  
  223.     error = GetCurrentContext(&context);
  224.     if (error)
  225.         return error;
  226.     dispatchProc = (*context.getCallerProc)(kAdjustMarksProc);
  227.     error = (*(AdjustMarksProcCaller)dispatchProc)(newStart, newStop,
  228.                                                     &markToken, context.refCon);
  229.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  230.     {
  231.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  232.         if (aGlobalRef)
  233.         {
  234.             OSLAdjustMarksUPP aProcPtr = (*aGlobalRef)->AdjustMarksProcPtr ;
  235.             if (aProcPtr)
  236.                 error = CallOSLAdjustMarksProc(aProcPtr, newStart, newStop,
  237.                                                 markToken);
  238.         }
  239.     }
  240.     return error;
  241. }
  242.  
  243. //------------------------------------------------------------------------------
  244. // NewCallMark
  245. //------------------------------------------------------------------------------
  246.  
  247. OSErr NewCallMark(OSLToken dToken, OSLToken  markToken, long n)
  248. {
  249.     CallbackCallerProc    dispatchProc;
  250.     OSLContext            context;
  251.     OSErr                error;
  252.  
  253.     error = GetCurrentContext(&context);
  254.     if (error)
  255.         return error;
  256.     dispatchProc = (*context.getCallerProc)(kMarkProc);
  257.     error = (*(MarkProcCaller)dispatchProc)(&dToken, &markToken, n,
  258.                                             context.refCon);
  259.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  260.     {
  261.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  262.         if (aGlobalRef)
  263.         {
  264.             OSLMarkUPP aProcPtr = (*aGlobalRef)->MarkProcPtr;
  265.             if (aProcPtr)
  266.                 error = CallOSLMarkProc(aProcPtr, dToken, markToken, n);
  267.         }
  268.     }
  269.     return error;
  270. }
  271.  
  272. //------------------------------------------------------------------------------
  273. // NewCallGetMarkToken
  274. //------------------------------------------------------------------------------
  275.  
  276. OSErr NewCallGetMarkToken(OSLToken dContainerToken, DescType containerClass,
  277.                             OSLToken *result)
  278. {
  279.     CallbackCallerProc    dispatchProc;
  280.     OSLContext            context;
  281.     OSErr                error;
  282.  
  283.     error = GetCurrentContext(&context);
  284.     if (error)
  285.         return error;
  286.     dispatchProc = (*context.getCallerProc)(kGetMarkTokenProc);
  287.     error = (*(GetMarkTokenProcCaller)dispatchProc)(&dContainerToken,
  288.                                                     containerClass,
  289.                                                     result,
  290.                                                     context.refCon);
  291.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  292.     {
  293.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  294.         if (aGlobalRef)
  295.         {
  296.             OSLGetMarkTokenUPP aProcPtr = (*aGlobalRef)->getMarkIDProcPtr;
  297.             if (aProcPtr)
  298.                 error = CallOSLGetMarkTokenProc(aProcPtr, dContainerToken,
  299.                                                 containerClass, result);
  300.         }
  301.     }
  302.     return error;
  303. }
  304.  
  305. //------------------------------------------------------------------------------
  306. // NewCallGetErrDesc
  307. //------------------------------------------------------------------------------
  308.  
  309. OSErr NewCallGetErrDesc(AEDesc* *appDescPtr)
  310. {
  311.     CallbackCallerProc    dispatchProc;
  312.     OSLContext            context;
  313.     OSErr                error;
  314.  
  315.     error = GetCurrentContext(&context);
  316.     if (error)
  317.         return error;
  318.     dispatchProc = (*context.getCallerProc)(kGetErrDescProc);
  319.     error = (*(GetErrDescProcCaller)dispatchProc)(appDescPtr, context.refCon);
  320.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  321.     {
  322.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  323.         if (aGlobalRef)
  324.         {
  325.             OSLGetErrDescUPP aProcPtr = (*aGlobalRef)->TypeAsIndexProc;
  326.             if (aProcPtr)
  327.                 error = CallOSLGetErrDescProc(aProcPtr, appDescPtr);
  328.         }
  329.     }
  330.     return error;
  331. }
  332.  
  333. //------------------------------------------------------------------------------
  334. // NewCallDisposeToken
  335. //
  336. //    Code in the orginal OSL already handles calling through to the system
  337. //    handler, if any.
  338. //------------------------------------------------------------------------------
  339.  
  340. OSErr NewCallDisposeToken(OSLToken* theToken)
  341. {
  342.     CallbackCallerProc    dispatchProc;
  343.     OSLContext            context;
  344.     OSErr                error;
  345.  
  346.     error = GetCurrentContext(&context);
  347.     if (error)
  348.         return error;
  349.     dispatchProc = (*context.getCallerProc)(kDisposeTokenProc);
  350.     return (*(DisposeTokenProcCaller)dispatchProc)(theToken, context.refCon);
  351. }
  352.  
  353. //==============================================================================
  354. // Grunge for linker
  355. //
  356. //    We use the same export files for PowerPC and 68K. However, these routine
  357. //    really need to be upper case in the 68K case (because they are pascal), but
  358. //    mixed case in the PowerPC case. Therefore, we have both versions of the
  359. //    routines in both builds. In the PowerPC case, the upper case names are
  360. //    not exported. In the 68K case, the upper case are exported, but you get
  361. //    link warnings because there are two definitions of them. It's OK, both
  362. //    versions are semantically identical.
  363. //==============================================================================
  364.  
  365. #pragma lib_export on
  366.  
  367. OSErr CREATEOBJSPECIFIER(DescType desiredClass, AEDesc *theContainer, DescType keyForm, AEDesc *keyData, Boolean disposeInputs, AEDesc *objSpecifier)
  368. {
  369.     return CreateObjSpecifier(desiredClass, theContainer, keyForm, keyData, disposeInputs, objSpecifier);
  370. }
  371.  
  372. OSErr CREATERANGEDESCRIPTOR(AEDesc *rangeStart, AEDesc *rangeStop, Boolean disposeInputs, AEDesc *theDescriptor)
  373. {
  374.     return CreateRangeDescriptor(rangeStart, rangeStop, disposeInputs, theDescriptor);
  375. }
  376.  
  377. OSErr CREATELOGICALDESCRIPTOR(AEDescList *theLogicalTerms, DescType theLogicOperator, Boolean disposeInputs, AEDesc *theDescriptor)
  378. {
  379.     return CreateLogicalDescriptor(theLogicalTerms, theLogicOperator, disposeInputs, theDescriptor);
  380. }
  381.  
  382. OSErr CREATEOFFSETDESCRIPTOR(long theOffset, AEDesc *theDescriptor)
  383. {
  384.     return CreateOffsetDescriptor(theOffset, theDescriptor);
  385. }
  386.  
  387. OSErr CREATECOMPDESCRIPTOR(DescType comparisonOperator, AEDesc *operand1, AEDesc *operand2, Boolean disposeInputs, AEDesc *theDescriptor)
  388. {
  389.     return CreateCompDescriptor(comparisonOperator, operand1, operand2, disposeInputs, theDescriptor);
  390. }
  391.  
  392.